package com.edvard.util;

import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.TimeZone;

import android.os.Bundle;
import android.widget.SimpleAdapter;

import com.edvard.bean.FiancialData;
import com.edvard.bean.FirstSubject;
import com.edvard.bean.SecondSubject;
import com.j256.ormlite.android.apptools.OrmLiteBaseActivity;
import com.j256.ormlite.dao.Dao;

/**
 * 财务汇总界面的基类，实现了如下几个算法
 *	借入总额：所有借入记录金额的合计
 *	应付息：所有借入记录的息的合计-所有还息记录的金额合计
 *	贷出总额：所有贷出记录的金额合计
 *	应收息：所有贷出记录的息的合计-所有收息记录的金额合计
 *	总资产：贷出总额+应收息-借入总额-应付息
 * @author cmb
 *
 */
public class ArithmeticActivity extends OrmLiteBaseActivity<DatabaseHelper>{
	
	protected Dao<FirstSubject, Integer> firstSubjectDao;
	protected Dao<SecondSubject, Integer> secondSubjectDao;
	protected Dao<FiancialData, Integer> fiancialDataDao;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		//取得Dao对象
		try {
			firstSubjectDao = getHelper().getFirstSubject();
			secondSubjectDao = getHelper().getSecondSubject();
			fiancialDataDao = getHelper().getFiancialData();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 得到所选类型的数据的列表
	 * @param firstId
	 * @param secondId
	 * @param type
	 * @return
	 */
	public List<FiancialData> getTypeDataList(Integer firstId,Integer secondId,Integer type){
		List<FiancialData> fiancialData = new ArrayList<FiancialData>();
		//查询的限定条件
		HashMap<String,Object> maps = new HashMap<String, Object>();
		//为空的时候，就只按照类型进行帅选
		if(firstId != null)
			maps.put("first_id", firstId);
		if(secondId != null)
			maps.put("second_id", secondId);
		//筛选的类型，已经是否已经在历史记录中
		maps.put("type_id", type);
		maps.put("is_in_history", DataType.NOTINHISTROY);
		try {
			//根据条件查询数据
			fiancialData = fiancialDataDao.queryForFieldValues(maps);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return fiancialData;
	}
	
	/**
	 * 取得某类数据总和的方法
	 * @param firstId
	 * @param secondId
	 * @param type
	 * @return
	 */
	public double getDataSum(Integer firstId,Integer secondId,Integer type){
		double money = 0.0;
		//查询得到全部行的数组
		List<FiancialData> fiancialData = getTypeDataList(firstId, secondId, type);
		//将数组里面每个数据的金额加起来
		for(FiancialData temp:fiancialData){
			money += temp.getMoney();
		}
		return money;
	}
	
	/**
	 * 计算每一条记录到当前时间的利息
	 * @param start
	 * @param end
	 * @param rate
	 * @return
	 */
	public double calEachInterest(long start,long end, double money, double rate){
		//计算两个long整形相差的天数
		int day = shuffDay(start, end);
		double interest = day * (money * rate);
		return interest;
	}
	
	/**
	 * 得到当前的利息
	 * @param data
	 * @return
	 */
	public double getInterest(List<FiancialData> data){
		double allInterest = 0.0;
		for(FiancialData temp: data){
			//以当前的时间减去开始的时间
			long start = Long.parseLong(temp.getStart_date());
			long end = System.currentTimeMillis();
			double money = temp.getMoney();
			double rate = temp.getRate();
			allInterest += calEachInterest(start, end, money, rate);
		}
		return allInterest;
	}
	
	/**
	 * 得到当最近的清单
	 * @param data
	 * @return
	 */
	public List<FiancialData> getRecentBill(List<FiancialData> data){
		int day = 0;
		List<FiancialData> fiancialData = new ArrayList<FiancialData>();
		for(FiancialData temp: data){
			long start = Long.parseLong(temp.getStart_date());
			long end = System.currentTimeMillis();
			day = shuffDay(start, end);
			if(day>=10){
				fiancialData.add(temp);
			}
		}
		return fiancialData;
	}
	
	
	/***************************得到全部的借入贷出应付和得息****************************/
	
	/**
	 * 得到最近借入的清单
	 * 
	 */
	public ArrayList<HashMap<String, Object>> getAllRecentBorrow(){
		//生成动态数组，加入数据  
        ArrayList<HashMap<String, Object>> listItem = new ArrayList<HashMap<String, Object>>(); 
		List<FiancialData> fiancialData = getRecentBill(getTypeDataList(null, null, DataType.BORROW));
		for(FiancialData temp: fiancialData){
			HashMap<String, Object> map = new HashMap<String, Object>();
			double money = temp.getMoney();
			map.put("money", "$ " + money);  
			int _id = temp.getSecond_id();
			if(_id == 1){
				map.put("name", "明标"); 
			}else{
				map.put("name", "Andy"); 
			}
			String date = temp.getEnd_date();
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
			String sd = sdf.format(new Date(Long.parseLong(date)));  
			map.put("time",""+ sd +"到期");
	        listItem.add(map);    
		}
		return listItem;
	}
	
	/**
	 * 得到最近贷出的清单
	 * 
	 */
	public ArrayList<HashMap<String, Object>> getAllRecentLoan(){
		//生成动态数组，加入数据  
        ArrayList<HashMap<String, Object>> listItem = new ArrayList<HashMap<String, Object>>(); 
		List<FiancialData> fiancialData = getRecentBill(getTypeDataList(null, null, DataType.LOAN));
		for(FiancialData temp: fiancialData){
			HashMap<String, Object> map = new HashMap<String, Object>();
			double money = temp.getMoney();
			map.put("money", "$ " + money);  
			int _id = temp.getSecond_id();
			if(_id == 1){
				map.put("name", "明标"); 
			}else{
				map.put("name", "Andy"); 
			}
			String date = temp.getEnd_date();
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
			String sd = sdf.format(new Date(Long.parseLong(date)));  
			map.put("time",""+ sd +"到期");
	        listItem.add(map);    
		}
		return listItem;
	}
	

	
	/**
	 * 得到当前所有的借入
	 * @return
	 */
	public double getAllBorrow(){
		return getDataSum(null, null, DataType.BORROW);
	}
	
	/**
	 * 得到当前所有的贷出
	 * @return
	 */
	public double getAllLoan(){
		return getDataSum(null, null, DataType.LOAN);
	}
	
	/**
	 * 得到全部已经收到的利息
	 * @return
	 */
	public double getAleadyGetInterest(){
		return getDataSum(null, null, DataType.GETINTEREST);
	}
	
	/**
	 * 得到全部已经支付的利息
	 * @return
	 */
	public double getAleadyPayInterest(){
		return getDataSum(null, null, DataType.PAYINTEREST);
	}
		
	/**
	 * 得到当前所有的应的利息
	 * @return
	 */
	public double getAllGetInterest(){
		return getInterest(getTypeDataList(null, null, DataType.LOAN)) - getAleadyGetInterest();
	}
	
	/**
	 * 得到当前所有应付利息
	 * @return
	 */
	public double getAllPayInterest(){
		return getInterest(getTypeDataList(null, null, DataType.BORROW)) - getAleadyPayInterest();
	}
	
	/**
	 * 得到当前总资产
	 * @return
	 */
	public double getAllAssets(){
		double allLoan = getAllLoan();
		double allGetInerest = getAllGetInterest();
		double allBorrow = getAllBorrow();
		double allPayInerest = getAllPayInterest();
		double aleadyPayInterest = getAleadyPayInterest();
		double aleadyGetInterest = getAleadyGetInterest();
		return allLoan + (allGetInerest-aleadyGetInterest) - allBorrow - (allPayInerest-aleadyPayInterest);
	}
	
	
	/***************************根据科目筛选*******************************************/
	
	/**
	 * 得到指定科目的所有未结清借入总额
	 * @param firstId
	 * @param secondId
	 * @return
	 */
	public double getBorrowByCategory(Integer firstId,Integer secondId){
		return getDataSum(firstId, secondId, DataType.BORROW);
	}
	
	/**
	 * 得到所有未结清借入总额的付息
	 * @return
	 */
	public double getPayInterestByCategory(Integer firstId,Integer secondId){
		return getInterest(getTypeDataList(firstId, secondId, DataType.BORROW)) - getAleadyPayInterest();
	}
	
	/**
	 * 得到指定科目的所有未结清的贷出总额
	 * @param firstId
	 * @param secondId
	 * @return
	 */
	public double getLoanByCategory(Integer firstId,Integer secondId){
		return getDataSum(firstId, secondId, DataType.LOAN);
	}
	
	/**
	 * 得到所有未结清应利息的值
	 * @return
	 */
	public double getGetInterestByCategory(Integer firstId,Integer secondId){
		return getInterest(getTypeDataList(firstId, secondId, DataType.LOAN)) - getAleadyGetInterest();
	}
	
	/**
	 * 根据科目筛选要得到的利息
	 * @param firstId
	 * @param secondId
	 * @return
	 */
	public double getAleadyGetInterestByCategory(Integer firstId,Integer secondId){
		return getDataSum(firstId,secondId, DataType.GETINTEREST);
	}
	
	/**
	 * 根据科目筛选要付的利息
	 * @param firstId
	 * @param secondId
	 * @return
	 */
	public double getAleadyPayInterestByCategory(Integer firstId,Integer secondId){
		return getDataSum(firstId,secondId, DataType.PAYINTEREST);
	}
	
	/**
	 * 计算当前所有未被结清的总资产
	 * @return
	 */
	public double getAssetsByCategory(Integer firstId,Integer secondId){
		double allLoan = getLoanByCategory(firstId, secondId);
		double allGetInerest = getGetInterestByCategory(firstId, secondId);
		double allBorrow = getBorrowByCategory(firstId, secondId);
		double allPayInerest = getPayInterestByCategory(firstId, secondId);
		double aleadyPayInterest = getAleadyPayInterestByCategory(firstId, secondId);
		double aleadyGetInterest = getAleadyGetInterestByCategory(firstId, secondId);
		return allLoan + (allGetInerest-aleadyGetInterest) - allBorrow - (allPayInerest-aleadyPayInterest);
	}
	/******************************时间处理*****************************************/
	
	/**
	 * 根据毫秒来对时间位移（单位是天书）
	 * @param time 传入的时间
	 * @param day 位移的天书
	 * @return 返回位移后的时间
	 */
	public long shuffTime(long time,int day){
		return time += (day * 86400000);
	}
	
	/**
	 * 前后两个时间相差的天数
	 * @param start 开始的时间
	 * @param end 结束的时间
	 * @return 相差的天数
	 */
	public int shuffDay(long start,long end){
		long shuff = end - start;
		int days = (int)shuff/86400000;
		return days;
	}
}
